src/vegas_mode/render_pipeline.py (1)

154-158: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Unused loop variable flagged by Ruff (B007).

♻️ Rename to `_plugin_id`

-            for plugin_id, images in grouped:
+            for _plugin_id, images in grouped:
                 total_rows += len(images)
                 blocks.append(self._join_plugin_rows(images))

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/vegas_mode/render_pipeline.py` around lines 154 - 158, Rename the unused
plugin_id loop variable in the grouped iteration within the render pipeline to
_plugin_id, leaving total_rows accumulation and _join_plugin_rows processing
unchanged.

Source: Linters/SAST tools

src/common/scroll_helper.py (1)

268-273: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Stale invariant comments now that lead_gap is configurable.

Lines 268-272 (and the same claim at Line 329 and Lines 587-589) still state the image "already includes display_width pixels of blank padding at the start (added by create_scrolling_image)". With lead_gap=0 from Vegas mode that is no longer true. Behaviour is unaffected here, but the next reader will reason from a false premise — and calculate_dynamic_duration() still adds a full display_width of travel on top of total_scroll_width for the same reason.

📝 Suggested wording

-        # Calculate required total distance: total_scroll_width only.
-        # The image already includes display_width pixels of blank padding at the start
-        # (added by create_scrolling_image), so once scroll_position reaches
-        # total_scroll_width the last card has fully scrolled off the left edge.
-        # Adding display_width here would cause 1-2 extra wrap-arounds on wide chains.
+        # Calculate required total distance: total_scroll_width only.
+        # Any leading blank margin (lead_gap, display_width by default but 0 in
+        # Vegas mode) is already part of total_scroll_width, so once
+        # scroll_position reaches it the last card has scrolled off the left
+        # edge. Adding display_width here would cause 1-2 extra wrap-arounds.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/common/scroll_helper.py` around lines 268 - 273, Update the stale
invariant comments near required_total_distance, the corresponding comment
around line 329, and the comment near line 587 to reflect that the leading blank
padding depends on configurable lead_gap and may be zero in Vegas mode. Also
review calculate_dynamic_duration() and remove its unconditional extra
display_width travel, preserving distance calculations based on the actual
configured image padding and total_scroll_width.

scripts/dev/vegas_audit.py (1)

124-136: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

join_rows re-implements RenderPipeline._join_plugin_rows verbatim.

The docstring itself says "matching RenderPipeline._join_plugin_rows" — that's an explicit coupling this audit tool depends on for accuracy, but nothing enforces it. If the production join logic changes (e.g. gap handling, height calc), this copy will silently drift and the audit will report numbers that no longer reflect production, undermining the tool's own purpose ("pulls each one's content through the real PluginAdapter... composes... through the real ScrollHelper").

Consider extracting this into a small shared helper (e.g. in src/vegas_mode/geometry.py or a new render_utils.py) that both RenderPipeline and this script import.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@scripts/dev/vegas_audit.py` around lines 124 - 136, Extract the duplicated
row-composition logic from join_rows into a shared production helper, then
update both join_rows and RenderPipeline._join_plugin_rows to call it. Preserve
the existing single-image behavior, nonnegative gap handling, RGB canvas
creation, width/height calculations, and paste ordering so the audit uses the
exact production implementation.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

test/test_vegas_density.py (2)

411-486: 🎯 Functional Correctness | 🔵 Trivial | ⚡ Quick win

EXPECTED omits render_width_pct and min_content_separation despite both having full validate()+API bounds.

render_width_pct (10–100) and min_content_separation (0–256) are fully bounded on both sides in VegasModeConfig.validate() and in the api_v3.py numeric_fields table shown, yet TestApiBoundsMatchValidate.EXPECTED doesn't include them. Given this exact class of drift ("an additional mismatch for separator_width") was already found once in this PR, extending EXPECTED to cover these two closes an easy blind spot in the same regression net. lead_in_width, min_cycle_duration, and max_cycle_duration are correctly excluded since validate() doesn't enforce a matching bound for them.

♻️ Extend EXPECTED coverage

     EXPECTED = {
         'scroll_speed': (1, 200),
         'separator_width': (0, 128),
         'intra_plugin_gap': (0, 128),
+        'render_width_pct': (10, 100),
+        'min_content_separation': (0, 256),
         'target_fps': (30, 200),
         'buffer_ahead': (1, 5),
         'trim_threshold': (0, 254),
         'content_padding': (0, 128),
         'min_plugin_width': (0, 512),
         'plugins_per_cycle': (1, 50),
     }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@test/test_vegas_density.py` around lines 411 - 486, Extend
TestApiBoundsMatchValidate.EXPECTED with render_width_pct set to (10, 100) and
min_content_separation set to (0, 256), matching the bounds enforced by
VegasModeConfig.validate() and the API numeric_fields map. Leave lead_in_width,
min_cycle_duration, and max_cycle_duration excluded.

---

260-277: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Duplicate _pipeline helper across two test classes.

TestPluginBoundaryGaps._pipeline and TestMeasuredSeparation._pipeline are byte-for-byte identical (same FakeStream/DM doubles and RenderPipeline construction). Worth hoisting to a shared module-level fixture/helper to avoid the two drifting apart later.

Also applies to: 666-683

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@test/test_vegas_density.py` around lines 260 - 277, Hoist the duplicated
_pipeline helper shared by TestPluginBoundaryGaps and TestMeasuredSeparation
into a module-level helper or fixture. Preserve the existing FakeStream and DM
doubles, configuration handling, and RenderPipeline construction, then update
both test classes to reuse the shared implementation.

src/display_manager.py (1)

539-591: 🩺 Stability & Availability | 🔵 Trivial | ⚡ Quick win

render_size() relies on an unenforced capture_mode() precondition.

The docstring states this is "Only meaningful inside capture_mode()" because it swaps the shared self.image/self.matrix/self.draw in place without a lock. update_display() guards against exactly this race by checking self._capture_mode_active before touching the panel — but that guard only works if every caller of render_size() also entered capture_mode() first, and nothing in render_size() itself verifies that. If a future caller (or a refactor of PluginAdapter._render_at) invokes render_size() without pairing it with capture_mode(), a concurrent background thread calling update_display() (explicitly documented as possible from plugin "live" refresh threads) could push the narrowed, mid-render buffer to the physical panel — a visible flash of the wrong plugin's cropped content across the whole panel. Failing fast here (per the project's Fail Fast principle) would catch a future misuse immediately instead of surfacing as an intermittent hardware glitch.

🛡️ Guard against use outside capture_mode()

         real_matrix = self.matrix
         prev_image = getattr(self, 'image', None)
         prev_draw = getattr(self, 'draw', None)
+
+        if not self._capture_mode_active:
+            logger.warning(
+                "render_size() called outside capture_mode(); the render "
+                "loop could push a mid-swap buffer to hardware"
+            )

As per coding guidelines, "Validate inputs and handle errors early (Fail Fast principle)".

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/display_manager.py` around lines 539 - 591, Add an early guard at the
start of render_size() that verifies self._capture_mode_active is enabled before
changing self.image, self.draw, or self.matrix; raise the project’s established
misuse/error type when render_size() is called outside capture_mode(). Preserve
the existing no-op and restoration behavior for valid capture-mode usage.

Source: Coding guidelines

src/vegas_mode/render_pipeline.py (2)

472-482: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Two adjacent blocks guard on the same condition.

if result and self.sync_manager: is evaluated twice back to back; fold the lead-in positioning into the existing sync block.

♻️ Proposed merge

         if result and self.sync_manager:
             # When sync is active, start the leader past the lead-in gap so it
             # immediately shows content, leaving the follower on the blank gap
             # for a clean transition rather than near-end content wrapping
             # around. This tracks lead_in_width rather than assuming a full
             # display width of gap, which is no longer the default.
             self.scroll_helper.scroll_position = float(self.config.lead_in_width)
-
-        if result and self.sync_manager:
             # Signal follower that a new cycle started (triggers its own rebuild)
             self.sync_manager.send_new_cycle()

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/vegas_mode/render_pipeline.py` around lines 472 - 482, Merge the adjacent
`if result and self.sync_manager` blocks into one shared sync block, keeping the
`scroll_helper.scroll_position` lead-in assignment and
`self.sync_manager.send_new_cycle()` call in their current order and behavior.

---

210-236: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Docstring no longer matches the spacing rule.

Rows are spaced by separation_gap(target=min_content_separation, floor=intra_plugin_gap) — measured blank, not a flat intra_plugin_gap. The docstring still promises the latter.

As per coding guidelines, "Use docstrings for classes and complex functions".

♻️ Proposed doc fix

             A single image with the rows laid out left to right, separated by
-            ``intra_plugin_gap``. Returned unchanged when there is only one row,
-            which is the common case and avoids a pointless copy.
+            enough blank to reach ``min_content_separation`` of measured
+            separation, never less than ``intra_plugin_gap``. Returned unchanged
+            when there is only one row, which avoids a pointless copy.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/vegas_mode/render_pipeline.py` around lines 210 - 236, Update the
_join_plugin_rows docstring to describe spacing rows using measured separation
via separation_gap, with min_content_separation as the target and
intra_plugin_gap as the floor, instead of claiming a flat intra_plugin_gap. Keep
the rest of the docstring accurate, including the single-row unchanged behavior.

Source: Coding guidelines

test/test_vegas_density.py (2)

1009-1022: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Unused word_strip spans (RUF059) at two sites. Both tests unpack the span list from word_strip() and never use it; discard it explicitly.

• test/test_vegas_density.py#L1009-L1022: change img, spans = word_strip(...) to img, _ = ... and simplify {c for c in legal} to legal.
• test/test_vegas_density.py#L1061-L1069: change img, spans = word_strip(...) to img, _ = ....

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@test/test_vegas_density.py` around lines 1009 - 1022, Discard the unused span
result from word_strip in both test_cut_lands_in_an_item_gap_not_between_letters
sites: test/test_vegas_density.py lines 1009-1022 and 1061-1069 should unpack
into img and _. At the anchor site, also simplify the legal-set assertion to
compare cut_width directly against legal.

Source: Linters/SAST tools

---

974-999: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Two independent computations of letter positions.

Span ends are accumulated in the first loop while the paste loop recomputes sx + l_i * (letter_w + letter_gap). They agree today, but any change to spacing must be made twice. Painting inside the first loop (or deriving both from one helper) removes the duplication, and adding type hints matches the repo convention.

As per coding guidelines, "Use type hints for function parameters and return values".

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@test/test_vegas_density.py` around lines 974 - 999, Update word_strip to use
a single letter-position calculation: paint each letter while accumulating its
position in the existing construction loop, and derive spans and image width
from that same accumulation instead of recomputing positions in a second loop.
Add type hints for all parameters and the tuple return value, preserving the
current spacing and rendered output.

Source: Coding guidelines

src/vegas_mode/geometry.py (2)

233-269: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Wire or remove find_item_boundary.

find_item_boundary is only defined, while _crop_to_budget still computes gaps directly with blank_runs. Either route the budgeted crop through this helper so item-level blank columns are consistently selected, or remove it to keep the codebase aligned.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/vegas_mode/geometry.py` around lines 233 - 269, Update _crop_to_budget to
use find_item_boundary for selecting the cut column, reusing its min_run and
threshold behavior instead of computing gaps directly with blank_runs; preserve
the no-qualifying-gap path by leaving the image uncropped. If routing the crop
through the helper is not appropriate, remove find_item_boundary and its related
documentation instead.

---

195-230: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Python target is not declared, so prefer omitting zip strict=.

Adding strict=True only helps if the installed Python supports it; the project docs/scripts default to python3.13, but there is no explicit requires-python/target-version policy to make this refactor follow a runtime constraint.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/vegas_mode/geometry.py` around lines 195 - 230, Update the return
expression in blank_runs to omit any zip(strict=...) argument, preserving the
existing pairing of starts and ends. Do not introduce a Python-version
requirement or target policy; keep the vectorized run detection unchanged.

Source: Linters/SAST tools

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

test/test_vegas_density.py (2)

1156-1156: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Redundant import inside the class body.

contextmanager is already imported at module level (line 6); this class-scoped re-import also leaks a contextmanager class attribute on RecordingDM.

♻️ Proposed cleanup

-        from contextlib import contextmanager
-
         `@contextmanager`
         def capture_mode(self):

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@test/test_vegas_density.py` at line 1156, Remove the redundant class-scoped
contextmanager import from RecordingDM, keeping the existing module-level import
for any class methods that use it and preventing contextmanager from becoming a
RecordingDM class attribute.

---

1491-1511: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Throttle tests depend on wall-clock and on the default extend_threshold_screens.

test_drains_are_spaced_when_lookahead_is_healthy and test_urgent_drain_ignores_the_throttle both hinge on DEFERRED_DRAIN_INTERVAL versus real time.time(), and on whether the seeded 600px strip is judged urgent under the config default. If either default changes these silently invert. Consider pinning extend_threshold_screens explicitly in _pipeline(...) for these two tests and monkeypatching the clock rather than relying on real elapsed time.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@test/test_vegas_density.py` around lines 1491 - 1511, Make the throttle tests
deterministic by explicitly setting extend_threshold_screens in _pipeline for
test_drains_are_spaced_when_lookahead_is_healthy and
test_urgent_drain_ignores_the_throttle, choosing values that preserve healthy
versus urgent behavior. Replace reliance on real time.time() with a
monkeypatched clock and advance it explicitly around DEFERRED_DRAIN_INTERVAL so
the expected deferred and immediate drain outcomes remain stable if defaults or
test timing change.

src/common/scroll_helper.py (1)

651-714: 🚀 Performance & Scalability | 🔵 Trivial | 💤 Low value

Each append reallocates the whole strip on the render thread.

np.concatenate plus Image.fromarray means every extension costs a full copy of the strip (peak = old + new simultaneously). Bounded by drop_scrolled_prefix, so it should stay under ~1 MB at 512×64, but on the Pi this lands on the render path. If extension hitches show up in profiling, consider growing into a pre-allocated buffer with slack columns and tracking a logical width instead of resizing exactly. No change needed now.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/common/scroll_helper.py` around lines 651 - 714, The reviewer notes a
potential render-thread performance concern in append_content, but explicitly
requests no change now. Leave the np.concatenate and Image.fromarray
implementation unchanged; do not add a preallocated buffer, slack capacity, or
logical-width refactor.

src/display_manager.py (1)

529-537: 🩺 Stability & Availability | 🔵 Trivial | ⚡ Quick win

Capture state is a boolean, so nested capture_mode() releases suppression too early.

capture_mode() sets the flag then clears it unconditionally in finally. If two capture scopes ever nest on the same thread (e.g. an adapter path that wraps _capture() around code that itself enters capture), the inner exit re-enables hardware writes while the outer scope is still capturing — the exact flash this mechanism exists to prevent. Note the new test double in test/test_vegas_density.py models this as a capture_depth counter, which suggests depth semantics are the intended contract.

🛡️ Proposed fix — depth-counted thread-local

     `@property`
     def _capture_mode_active(self) -> bool:
         """True while the calling thread is capturing content off-screen."""
-        return getattr(self._capture_state, 'active', False)
+        return getattr(self._capture_state, 'depth', 0) > 0
 
     `@_capture_mode_active.setter`
     def _capture_mode_active(self, value: bool) -> None:
-        self._capture_state.active = bool(value)
+        depth = getattr(self._capture_state, 'depth', 0)
+        self._capture_state.depth = depth + 1 if value else max(0, depth - 1)

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/display_manager.py` around lines 529 - 537, Update the capture state used
by _capture_mode_active and capture_mode() from a boolean to a per-thread
nesting depth, incrementing on entry and decrementing on exit without allowing
premature suppression release. Keep _capture_mode_active true while depth is
greater than zero, including across nested capture scopes, and preserve the
existing thread-local behavior.

src/vegas_mode/coordinator.py (1)

309-324: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

cycles_completed now counts strip extensions, and live updates no longer reach visible content.

Two observations on this branch:

• A successful extend_scroll_content() increments stats['cycles_completed'], but an extension is not a cycle — the reported status will inflate steadily. render_pipeline.stats['extensions'] already tracks this; consider a separate extensions counter here.
• The should_recompose() / hot_swap_content() path is skipped in continuous mode, so a live score change on a plugin already composed into the strip stays stale until that plugin rotates back round. Worth confirming that's the intended trade for continuous motion.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/vegas_mode/coordinator.py` around lines 309 - 324, Update the
continuous-scroll branch in the coordinator flow so successful
render_pipeline.extend_scroll_content() calls do not increment
stats['cycles_completed']; track extensions separately or rely on
render_pipeline.stats['extensions'], while reserving cycles_completed for actual
cycle transitions. Also ensure the should_recompose()/hot_swap_content() path
runs for continuous mode so live updates reach plugins already composed into the
strip without interrupting scrolling.

test/test_scroll_helper_continuous.py (1)

20-26: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Add type hints to the test helper factories.

helper() and block() lack parameter/return type hints.

As per coding guidelines, "Use type hints for function parameters and return values."

♻️ Proposed fix

-def helper():
+def helper() -> ScrollHelper:
     return ScrollHelper(W, H)


-def block(width, colour=(255, 255, 255), height=H):
+def block(width: int, colour: tuple[int, int, int] = (255, 255, 255), height: int = H) -> Image.Image:
     return Image.new('RGB', (width, height), colour)

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@test/test_scroll_helper_continuous.py` around lines 20 - 26, Add parameter
and return type annotations to the helper() and block() test factory functions,
using the appropriate types for their arguments and the ScrollHelper and Image
return values. Preserve their existing behavior and defaults.

Source: Coding guidelines

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

test/test_vegas_density.py (1)

1521-1577: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Apply the repository’s Python test conventions. Add concise docstrings to the Cfg stubs and TestPerPluginWidthBudget, and annotate fixture/test methods (including cfg, bad, and -> None return types).

• test/test_vegas_density.py#L1521-L1577: document and type-annotate TestOverflowMode.Cfg and its test methods.
• test/test_vegas_density.py#L1580-L1639: add the missing suite docstring and annotate TestPerPluginWidthBudget.Cfg and its test methods.

As per coding guidelines, “Use docstrings for classes and complex functions” and “Use type hints for function parameters and return values.”

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@test/test_vegas_density.py` around lines 1521 - 1577, In
test/test_vegas_density.py:1521-1577, add concise docstrings to
TestOverflowMode.Cfg and annotate its fixture/test methods, including cfg, bad,
and -> None; in test/test_vegas_density.py:1580-1639, add the
TestPerPluginWidthBudget suite docstring, document its Cfg stub, and add
parameter and return type annotations to all fixture/test methods. Preserve
existing test behavior.

Source: Coding guidelines

src/common/scroll_helper.py (1)

745-773: 🩺 Stability & Availability | 🔵 Trivial | ⚡ Quick win

Guard the strip-growing allocation against MemoryError.

np.concatenate + Image.fromarray allocate a new buffer the size of the whole (growing) strip. On a RAM-constrained Raspberry Pi, an OOM here isn't caught by the caller (extend_scroll_content() only catches ValueError, TypeError, OSError, RuntimeError), so it would propagate out of the render loop.

♻️ Proposed fix for graceful degradation on OOM

-        self.cached_array = np.concatenate(
-            (self.cached_array, np.array(addition)), axis=1)
-        self.cached_image = Image.fromarray(self.cached_array)
+        try:
+            new_array = np.concatenate(
+                (self.cached_array, np.array(addition)), axis=1)
+            new_image = Image.fromarray(new_array)
+        except MemoryError:
+            self.logger.error(
+                "Out of memory appending %dpx to scroll strip (current %dpx); skipping append",
+                addition_width, self.total_scroll_width)
+            return False
+        self.cached_array = new_array
+        self.cached_image = new_image
         self.total_scroll_width = self.cached_image.width
         self.scroll_complete = False

As per coding guidelines, "Optimize code for Raspberry Pi's limited RAM and CPU capabilities" and "Implement graceful degradation to continue operation when non-critical features fail."

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/common/scroll_helper.py` around lines 745 - 773, Guard the strip-growing
allocation in the append flow around `np.concatenate` and `Image.fromarray` with
`MemoryError` handling. On allocation failure, log the failure, leave the
existing cached strip and scroll state unchanged, and return `False` so
`extend_scroll_content()` can continue gracefully.

Source: Coding guidelines

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes